import { defineConfig } from 'vitepress'
import fs from 'fs'
import path from 'path'

// 定义基础路径，避免使用硬编码的相对路径
const BASE_DIR = path.resolve(__dirname, '../..')
const TABLES_DIR = path.join(BASE_DIR, 'tables')
const TYPES_DIR = path.join(BASE_DIR, 'types')
const DOCS_DIR = path.join(BASE_DIR, 'docs')

// 创建表格和类型的索引页
function createIndexPages() {
    // 创建表格索引页
    const tablesIndexPath = path.join(DOCS_DIR, 'tables', 'index.md')
    fs.mkdirSync(path.dirname(tablesIndexPath), { recursive: true })
    if (!fs.existsSync(tablesIndexPath)) {
        fs.writeFileSync(tablesIndexPath, `# 数据表文档

使用 TableViewer 组件可以浏览所有表格文档。

<TableViewer />
`)
    }

    // 创建类型索引页
    const typesIndexPath = path.join(DOCS_DIR, 'types', 'index.md')
    fs.mkdirSync(path.dirname(typesIndexPath), { recursive: true })
    if (!fs.existsSync(typesIndexPath)) {
        fs.writeFileSync(typesIndexPath, `# TypeScript类型定义浏览器

该页面列出了所有自动生成的TypeScript类型定义。

<TypeViewer />
`)
    }

    // 创建表格页面
    createTablePages()
    createTypePages()
}

// 为每个表创建页面
function createTablePages() {
    try {
        // 检查表格目录是否存在
        if (!fs.existsSync(TABLES_DIR)) {
            console.warn(`表格目录不存在: ${TABLES_DIR}`)
            return
        }

        const files = fs.readdirSync(TABLES_DIR)
            .filter(file => file.endsWith('.md') && file !== 'tables_summary.md')

        // 为每个表创建一个页面
        files.forEach(file => {
            const name = file.replace('.md', '')
            const pagePath = path.join(DOCS_DIR, 'tables', `${name}.md`)

            fs.mkdirSync(path.dirname(pagePath), { recursive: true })

            if (!fs.existsSync(pagePath)) {
                fs.writeFileSync(pagePath, `# ${name} 表文档

<TableViewer />
`)
            }
        })
    } catch (error) {
        console.error(`创建表格页面失败: ${error.message}`)
    }
}

// 为每个类型创建页面
function createTypePages() {
    try {
        // 检查类型目录是否存在
        if (!fs.existsSync(TYPES_DIR)) {
            console.warn(`类型目录不存在: ${TYPES_DIR}`)
            return
        }

        const files = fs.readdirSync(TYPES_DIR)
            .filter(file => file.endsWith('.ts') && file !== 'index.ts')

        // 为每个类型创建一个页面
        files.forEach(file => {
            const name = file.replace('.ts', '')
            const pagePath = path.join(DOCS_DIR, 'types', `${name}.md`)

            fs.mkdirSync(path.dirname(pagePath), { recursive: true })

            if (!fs.existsSync(pagePath)) {
                fs.writeFileSync(pagePath, `# ${name} 类型定义

<TypeViewer />
`)
            }
        })
    } catch (error) {
        console.error(`创建类型页面失败: ${error.message}`)
    }
}

// 创建索引页面
try {
    createIndexPages()
} catch (error) {
    console.error(`创建索引页面出错: ${error.message}`)
}

// 动态获取表文档文件
function getTableDocs() {
    try {
        const files = fs.readdirSync(TABLES_DIR)
            .filter(file => file.endsWith('.md') && file !== 'tables_summary.md')
            .sort()

        // 按前缀分组
        const groups = {}

        files.forEach(file => {
            const name = file.replace('.md', '')
            const prefix = name.split('_')[0]

            if (!groups[prefix]) {
                groups[prefix] = []
            }

            groups[prefix].push({
                text: name,
                link: `/tables/${name}`
            })
        })

        // 转换为侧边栏项数组
        return Object.entries(groups).map(([prefix, items]) => {
            return {
                text: `${prefix} 模块`,
                collapsed: true,
                items
            }
        })
    } catch (error) {
        console.error(`读取表文档目录失败: ${error.message}`)
        return []
    }
}

// 动态获取类型定义文件
function getTypeDefinitions() {
    try {
        const files = fs.readdirSync(TYPES_DIR)
            .filter(file => file.endsWith('.ts') && file !== 'index.ts')
            .sort()

        // 按前缀分组
        const groups = {}

        files.forEach(file => {
            const name = file.replace('.ts', '')
            const prefix = name.split('_')[0]

            if (!groups[prefix]) {
                groups[prefix] = []
            }

            groups[prefix].push({
                text: name,
                link: `/types/${name}`
            })
        })

        // 转换为侧边栏项数组
        return Object.entries(groups).map(([prefix, items]) => {
            return {
                text: `${prefix} 模块`,
                collapsed: true,
                items
            }
        })
    } catch (error) {
        console.error(`读取类型定义目录失败: ${error.message}`)
        return []
    }
}

export default defineConfig({
    title: '金牛座API文档与类型生成工具',
    description: '数据库表文档和TypeScript类型定义',
    base: '/',
    lastUpdated: true,

    head: [
        ['link', { rel: 'icon', href: '/favicon.ico' }],
        ['meta', { name: 'theme-color', content: '#3c8772' }],
        ['link', { rel: 'stylesheet', href: 'https://unpkg.com/element-plus/dist/index.css' }]
    ],

    themeConfig: {
        logo: '/logo.png',

        nav: [
            { text: '首页', link: '/' },
            { text: '使用指南', link: '/guide/' },
            { text: '表文档', link: '/tables/' },
            { text: '类型定义', link: '/types/' },
            { text: 'API构建工具', link: '/api-builder' },
            { text: '关于我们', link: '/guide/about' }
        ],

        sidebar: {
            '/guide/': [
                {
                    text: '使用指南',
                    items: [
                        { text: '介绍', link: '/guide/' },
                        { text: '文件结构说明', link: '/guide/file-structure' },
                        { text: '命令行工具', link: '/guide/cli' },
                        { text: '配置管理', link: '/guide/config' },
                        { text: '工作原理', link: '/guide/principle' },
                        { text: '开发任务计划', link: '/guide/dev-plan' },
                        { text: '贡献待办任务', link: '/guide/tasks' },
                        { text: 'API构建工具', link: '/api-builder' },
                        { text: '常见问题', link: '/guide/faq' },
                        { text: '关于我们', link: '/guide/about' }
                    ]
                }
            ],
            '/tables/': [
                {
                    text: '数据库表文档',
                    items: [
                        { text: '表概览', link: '/tables/' },
                        ...getTableDocs()
                    ]
                }
            ],
            '/types/': [
                {
                    text: 'TypeScript类型定义',
                    items: [
                        { text: '类型概览', link: '/types/' },
                        ...getTypeDefinitions()
                    ]
                }
            ]
        },

        socialLinks: [
            { icon: 'github', link: 'https://github.com' }
        ],

        footer: {
            message: '使用金牛座API文档与类型生成工具构建',
            copyright: 'Copyright © 2024'
        },

        search: {
            provider: 'local'
        },

        // 定制化设置
        outDir: '../public/docs',
        cacheDir: '../.vitepress/cache',
        srcExclude: ['**/README.md', '**/TODO.md'],

        // 代码复制功能
        markdown: {
            theme: 'github-dark',
            lineNumbers: true
        }
    },

    // 实时重载配置 - 加强监听
    vite: {
        server: {
            watch: {
                usePolling: true,
                interval: 500,
                binaryInterval: 1000,
                ignored: ['!**/node_modules/**', '!**/.git/**'],
                disableGlobbing: false,
            },
            hmr: {
                overlay: true,
            },
            // 添加静态资源处理
            fs: {
                allow: ['..', '../..']  // 允许访问上级目录
            }
        },
        optimizeDeps: {
            include: ['element-plus', 'marked', 'prismjs']
        },
        resolve: {
            alias: {
                '@tables': path.resolve(__dirname, '../../tables/'),
                '@types': path.resolve(__dirname, '../../types/')
            }
        },
        configureServer(server) {
            // 添加中间件处理API请求
            server.middlewares.use((req, res, next) => {
                // 记录请求，便于调试
                console.log(`[API Request]: ${req.method} ${req.url}`)

                // 处理API请求
                if (req.url === '/api/tables') {
                    console.log('处理表格列表请求')
                    try {
                        // 获取表格列表
                        const tablesDir = path.resolve(__dirname, '../../tables')
                        let tableData = { tables: [] }

                        // 先尝试从静态JSON文件加载
                        const tableListPath = path.resolve(__dirname, '../../tables/table-list.json')
                        if (fs.existsSync(tableListPath)) {
                            try {
                                const tableListContent = fs.readFileSync(tableListPath, 'utf-8')
                                tableData = JSON.parse(tableListContent)
                            } catch (err) {
                                console.error('解析table-list.json失败:', err)
                                // 继续使用动态生成的表格列表
                            }
                        }

                        // 如果没有从静态文件加载到数据，则动态生成
                        if (!tableData.tables || tableData.tables.length === 0) {
                            if (fs.existsSync(tablesDir)) {
                                const files = fs.readdirSync(tablesDir)
                                tableData.tables = files
                                    .filter(file => file.endsWith('.md'))
                                    .map(file => {
                                        // 从文件名中提取表名
                                        const tableName = file.replace('.md', '')
                                        return {
                                            name: tableName,
                                            description: `${tableName}表`,
                                            path: `/tables/${file}`,
                                            updateTime: new Date().toISOString()
                                        }
                                    })
                            }
                        }

                        // 设置响应头和返回数据
                        res.setHeader('Content-Type', 'application/json')
                        res.statusCode = 200
                        res.end(JSON.stringify(tableData))
                        return
                    } catch (err) {
                        console.error('处理表格列表请求错误:', err)
                        res.setHeader('Content-Type', 'application/json')
                        res.statusCode = 500
                        res.end(JSON.stringify({ error: err.message || '获取表格列表失败' }))
                        return
                    }
                }

                // 处理类型请求
                if (req.url === '/api/types') {
                    console.log('处理类型列表请求')
                    try {
                        // 获取类型列表
                        const typesDir = path.resolve(__dirname, '../../types')
                        let typeData = { types: [] }

                        // 先尝试从静态JSON文件加载
                        const typeListPath = path.resolve(__dirname, '../../types/type-list.json')
                        if (fs.existsSync(typeListPath)) {
                            try {
                                const typeListContent = fs.readFileSync(typeListPath, 'utf-8')
                                typeData = JSON.parse(typeListContent)
                            } catch (err) {
                                console.error('解析type-list.json失败:', err)
                                // 继续使用动态生成的类型列表
                            }
                        }

                        // 如果没有从静态文件加载到数据，则动态生成
                        if (!typeData.types || typeData.types.length === 0) {
                            if (fs.existsSync(typesDir)) {
                                const files = fs.readdirSync(typesDir)
                                typeData.types = files
                                    .filter(file => file.endsWith('.ts'))
                                    .map(file => {
                                        return {
                                            name: file,
                                            description: `${file.replace('.ts', '')}类型定义`,
                                            path: `/types/${file}`,
                                            updateTime: new Date().toISOString()
                                        }
                                    })
                            }
                        }

                        // 设置响应头和返回数据
                        res.setHeader('Content-Type', 'application/json')
                        res.statusCode = 200
                        res.end(JSON.stringify(typeData))
                        return
                    } catch (err) {
                        console.error('处理类型列表请求错误:', err)
                        res.setHeader('Content-Type', 'application/json')
                        res.statusCode = 500
                        res.end(JSON.stringify({ error: err.message || '获取类型列表失败' }))
                        return
                    }
                }

                // 处理原始表格内容请求
                if (req.url.startsWith('/raw-tables/')) {
                    const tableName = req.url.replace('/raw-tables/', '')
                    console.log(`获取表格内容: ${tableName}`)

                    try {
                        const tablePath = path.resolve(__dirname, `../../tables/${tableName}`)
                        if (fs.existsSync(tablePath)) {
                            const content = fs.readFileSync(tablePath, 'utf-8')
                            res.setHeader('Content-Type', 'text/plain')
                            res.statusCode = 200
                            res.end(content)
                            return
                        } else {
                            res.statusCode = 404
                            res.end(`表格 ${tableName} 不存在`)
                            return
                        }
                    } catch (err) {
                        console.error(`读取表格内容错误 ${tableName}:`, err)
                        res.statusCode = 500
                        res.end(`读取表格内容错误: ${err.message}`)
                        return
                    }
                }

                // 处理原始类型内容请求
                if (req.url.startsWith('/raw-types/')) {
                    const typeName = req.url.replace('/raw-types/', '')
                    console.log(`获取类型内容: ${typeName}`)

                    try {
                        const typePath = path.resolve(__dirname, `../../types/${typeName}`)
                        if (fs.existsSync(typePath)) {
                            const content = fs.readFileSync(typePath, 'utf-8')
                            res.setHeader('Content-Type', 'text/plain')
                            res.statusCode = 200
                            res.end(content)
                            return
                        } else {
                            res.statusCode = 404
                            res.end(`类型 ${typeName} 不存在`)
                            return
                        }
                    } catch (err) {
                        console.error(`读取类型内容错误 ${typeName}:`, err)
                        res.statusCode = 500
                        res.end(`读取类型内容错误: ${err.message}`)
                        return
                    }
                }

                // 处理API构建工具的请求代理
                if (req.url.startsWith('/api-proxy/')) {
                    const apiUrl = req.url.replace('/api-proxy/', '')
                    const targetUrl = decodeURIComponent(apiUrl)
                    console.log(`API代理请求: ${targetUrl}`)

                    // 这里您可以添加实际的代理逻辑
                    // 例如使用http或https模块转发请求
                    // 简单返回示例
                    res.setHeader('Content-Type', 'application/json')
                    res.statusCode = 200
                    res.end(JSON.stringify({
                        success: true,
                        message: '这是一个API代理示例响应',
                        request: {
                            url: targetUrl,
                            method: req.method
                        }
                    }))
                    return
                }

                next()
            })
        }
    },

    // 保留只有文件监控功能的configureServer
    async configureServer(server) {
        // 监听目录变化
        const MONITORED_DIRS = [
            TABLES_DIR,
            TYPES_DIR
        ];

        // 监听文件变化
        for (const dir of MONITORED_DIRS) {
            server.watcher.add(dir)
        }

        server.watcher.on('change', (path) => {
            console.log(`File changed: ${path}`)
            // 文件变化时会自动触发客户端刷新
        })
    }
}) 